IRIX Base Documentation 1998 November/IRIX 6.5.2 Base Documentation November 1998.img/usr/share/catman/p_man/cat3/ifl/iflFormat.z/iflFormat

Text File | 1998-10-20 | 32KB | 595 lines

iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



NNNNAAAAMMMMEEEE
     iiiiffffllllFFFFoooorrrrmmmmaaaatttt - abstraction of an image file format

IIIINNNNHHHHEEEERRRRIIIITTTTSSSS FFFFRRRROOOOMMMM
     This is a base class with no inheritance.


HHHHEEEEAAAADDDDEEEERRRR FFFFIIIILLLLEEEE
     #include <il/iflFormat.h>


CCCCLLLLAAAASSSSSSSS DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
     An iflFormat object represents a description of the capabilities of a
     particular image file format.  Usually there exists at most one such
     object per file format in a running program; functions that return
     iflFormat*s (such as iiiiffffllllFFFFiiiilllleeee::::::::ggggeeeettttFFFFoooorrrrmmmmaaaatttt()) generally return a pointer to
     the single static object of the appropriate subclass of iflFormat.

     iflFormat is an abstract base class; every iflFormat object is actually
     an object of a file-format-specific subclass such as iflTIFFFormat.

   FFFFoooorrrrmmmmaaaatttt llllooooooookkkkuuuupppp ffffuuuunnnnccccttttiiiioooonnnnssss
     An IFL application can use the ffffiiiinnnnddddNNNNeeeexxxxtttt(), ffffiiiinnnnddddBBBByyyyMMMMaaaaggggiiiicccc(),
     ffffiiiinnnnddddBBBByyyyFFFFoooorrrrmmmmaaaattttNNNNaaaammmmeeee() and ffffiiiinnnnddddBBBByyyyFFFFiiiilllleeeeNNNNaaaammmmeeee() functions to step through all
     supported file formats, or to look up an image file format by format
     name, file name, or file magic number.  The return value of each of these
     functions is an iflFormat* pointing to the single static object of the
     appropriate subclass of iflFormat (such as iflTIFFFormat).

   SSSSuuuuppppppppoooorrrrtttteeeedddd aaaattttttttrrrriiiibbbbuuuutttteeee qqqquuuueeeerrrriiiieeeessss
     These ...IsSupported() functions tell whether a given value of a given
     image attribute is supported by the image file format.

     Note that certain combinations of parameters might not be supported, even
     if each parameter is individually supported; thus these functions cannot
     give a definitive positive answer for support of a set of parameters,
     though they may give a definitive negative answer.

   PPPPrrrreeeeffffeeeerrrrrrrreeeedddd aaaattttttttrrrriiiibbbbuuuutttteeee qqqquuuueeeerrrriiiieeeessss
     The getPreferred...() virtual member functions return the image file
     format's "preferred" value for the respective attributes. The returned
     value must be one of the supported values for that parameter, as reported
     by the corresponding "isSupported" method.

DDDDEEEERRRRIIIIVVVVIIIINNNNGGGG SSSSUUUUBBBBCCCCLLLLAAAASSSSSSSSEEEESSSS
     The derived class must define all of iflFormat's pure virtuals:
     aaaacccccccceeeessssssssMMMMooooddddeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(), ttttyyyyppppeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(), oooorrrrddddeeeerrrrIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(),
     oooorrrriiiieeeennnnttttaaaattttiiiioooonnnnIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(), ccccoooolllloooorrrrMMMMooooddddeeeellllIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(),
     ccccoooommmmpppprrrreeeessssssssiiiioooonnnnIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(), ssssiiiizzzzeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(), ppppaaaaggggiiiinnnnggggIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(),
     ppppaaaaggggeeeeSSSSiiiizzzzeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(), rrrraaaannnnddddoooommmmAAAAcccccccceeeessssssssRRRReeeeaaaaddddIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(),
     rrrraaaannnnddddoooommmmAAAAcccccccceeeessssssssWWWWrrrriiiitttteeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(), ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddTTTTyyyyppppeeee(), ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddOOOOrrrrddddeeeerrrr(),
     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn(), ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddCCCCoooolllloooorrrrMMMMooooddddeeeellll(),



                                                                        PPPPaaaaggggeeee 1111






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddCCCCoooommmmpppprrrreeeessssssssiiiioooonnnn(), ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddPPPPaaaaggggeeeeSSSSiiiizzzzeeee() and nnnneeeewwwwffffiiiilllleeeeoooobbbbjjjj().  This
     will fully characterize the format, and, via nnnneeeewwwwffffiiiilllleeeeoooobbbbjjjj(), will tell
     iiiiffffllllFFFFiiiilllleeee::::::::ooooppppeeeennnn() how to create an iflFile of this format's type.

     Each image file format subclass format is expected to declare a single
     static object of its derived type. The base class constructor invoked
     automatically when the DSO is opened (becuase of the static object
     declaration) will put the derived format on the global format list as
     part of its initialization.

     If you instal ifl_dev.sw.gifts then you can check out the source code
     provided in /usr/share/src/ifl for more examples of deriving from
     iflFormat.


CCCCLLLLAAAASSSSSSSS MMMMEEEEMMMMBBBBEEEERRRR FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN SSSSUUUUMMMMMMMMAAAARRRRYYYY
   CCCCoooonnnnssssttttrrrruuuuccccttttoooorrrr
          iflFormat(const char* formatName)  _p_r_o_t_e_c_t_e_d


   FFFFoooorrrrmmmmaaaatttt llllooooooookkkkuuuupppp
          static iflFormat* findNext(int& index, int openDSOifNecessary = TRUE)
          static iflFormat* findByMagic(int fd, int openDSOifNecessary = TRUE)
          static iflFormat* findByFormatName(const char* formatName,
                                             int openDSOifNecessary = TRUE)
          static iflFormat* findByFileName(const char* fileName,
                                           int noMatchRule = FALSE,
                                           int openDSOifNecessary = TRUE)


   AAAAttttttttrrrriiiibbbbuuuutttteeee qqqquuuueeeerrrriiiieeeessss
          const char* getName()
          const char* getDefaultSuffix()
          const char* getDescription()


   AAAAttttttttrrrriiiibbbbuuuutttteeee ssssuuuuppppppppoooorrrrtttt qqqquuuueeeerrrriiiieeeessss
          int accessModeIsSupported(int mode)
          virtual int typeIsSupported(iflDataType type)
          virtual int orderIsSupported(iflOrder order)
          virtual int orientationIsSupported(iflOrientation orientation)
          virtual int colorModelIsSupported(iflColorModel colormodel)
          virtual int compressionIsSupported(iflCompression compression)
          virtual int sizeIsSupported(int width, int height, int z,
                                      int c, iflOrientation orientation)
          virtual int pagingIsSupported()
          virtual int pageSizeIsSupported(int iWidth, int iHeight,
                                          int iz, int ic, int pWidth,
                                          int pHeight, int pz,
                                          int pc, iflOrientation orientation)
          virtual int randomAccessReadIsSupported()
          virtual int randomAccessWriteIsSupported()



                                                                        PPPPaaaaggggeeee 2222






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



   AAAAttttttttrrrriiiibbbbuuuutttteeee pppprrrreeeeffffeeeerrrreeeennnncccceeee qqqquuuueeeerrrriiiieeeessss
          virtual iflDataType getPreferredType()
          virtual iflOrder getPreferredOrder()
          virtual iflOrientation getPreferredOrientation()
          virtual iflColorModel getPreferredColorModel(int nc=0)
          virtual iflCompression getPreferredCompression()
          virtual void getPreferredPageSize(int iWidth, int iHeight,
                                            int iz, int ic, int& pWidth,
                                            int& pHeight, int& pz,
                                            int& pc, iflOrientation orientation)


   IIIInnnnhhhheeeerrrriiiittttiiiinnnngggg aaaattttttttrrrriiiibbbbuuuutttteeeessss
          iflStatus applyDefaults(iflFile* source, iflFileConfig& config)
          iflStatus applyDefaults(iflFileConfig* source, iflFileConfig& config)
          int haveDSOVersion(int major, int minor)
          int haveICC()



FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNNSSSS
     iiiiffffllllFFFFoooorrrrmmmmaaaatttt(((())))

          iflFormat(const char* formatName)  _p_r_o_t_e_c_t_e_d


          Derived classes should pass the name of the format as _f_o_r_m_a_t_N_a_m_e so
          the format will be properly registered in the database.  This name
          must match the name used in the 'ifl_database' file.

     aaaacccccccceeeessssssssMMMMooooddddeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          int accessModeIsSupported(int mode)


          This virtual member function tells whether the given access mode
          (which must be one of _O__R_D_O_N_L_Y, _O__W_R_O_N_L_Y, or _O__R_D_W_R) is supported by
          the subclass.

          Note that this function is also provided by iflDatabase, which gets
          the information from the FTR database without the overhead of
          opening any DSOs.

     aaaappppppppllllyyyyDDDDeeeeffffaaaauuuullllttttssss(((())))

          iflStatus applyDefaults(iflFile* source, iflFileConfig& config)
          iflStatus applyDefaults(iflFileConfig* source, iflFileConfig& config)


          These member functions attempt to change all of the parameters of
          the iflFileConfig, _c_o_n_f_i_g, that have the value 0 (i.e. don't care)
          to be reasonable values.  The values are inherited from the _s_o_u_r_c_e



                                                                        PPPPaaaaggggeeee 3333






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



          iflFile* (if it is non-NULL and the value is supported), the _s_o_u_r_c_e
          iflFileConfig* (if it is non-NULL and the value is supported), or
          are heuristically selected to be a supported value most suitable for
          copying data from the source iflFile* or iflFileConfig*.  If the
          _s_o_u_r_c_e iflFile* is NULL or the _s_o_u_r_c_e iflFileConfig* is NULL, the
          don't-care parameters are changed to the image file format's
          preferred values.

     ccccoooolllloooorrrrMMMMooooddddeeeellllIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int colorModelIsSupported(iflColorModel colormodel)


          This virtual member function tells whether the given color model is
          supported by the image file format.

     ccccoooommmmpppprrrreeeessssssssiiiioooonnnnIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int compressionIsSupported(iflCompression compression)


          This virtual member function tells whether the given compression is
          supported by the image file format.

     ffffiiiinnnnddddBBBByyyyFFFFiiiilllleeeeNNNNaaaammmmeeee(((())))

          static iflFormat* findByFileName(const char* fileName,
                                           int noMatchRule = FALSE,
                                           int openDSOifNecessary = TRUE)


          This static class member function is used to look up an image file
          format by file name, where the file name is given by the _f_i_l_e_n_a_m_e
          argument.  This is accomplished by matching the filename against
          against the iflExtensions variable given for each image file format
          in the FTR database.

          The _n_o_M_a_t_c_h_R_u_l_e argument can be used to limit searching to those
          formats that have no match rule.

          The _o_p_e_n_D_S_O_i_f_N_e_c_e_s_s_a_r_y argument can be used to limit searching to
          those formats whose DSOs have already been opened.

     ffffiiiinnnnddddBBBByyyyFFFFoooorrrrmmmmaaaattttNNNNaaaammmmeeee(((())))

          static iflFormat* findByFormatName(const char* formatName,
                                             int openDSOifNecessary = TRUE)


          This static class member function is used to look up an image file
          format by name, where the name is given by the _f_o_r_m_a_t_n_a_m_e argument.




                                                                        PPPPaaaaggggeeee 4444






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



          The _o_p_e_n_D_S_O_i_f_N_e_c_e_s_s_a_r_y argument can be used to limit searching to
          those formats whose DSOs have already been opened.

     ffffiiiinnnnddddBBBByyyyMMMMaaaaggggiiiicccc(((())))

          static iflFormat* findByMagic(int fd, int openDSOifNecessary = TRUE)


          This static class member function is used to look up an image file
          format by magic number of a given file that is open for reading.

          The _f_d argument is a file descriptor referring to the file.

          The _o_p_e_n_D_S_O_i_f_N_e_c_e_s_s_a_r_y argument can be used to limit searching to
          those formats whose DSOs have already been opened.

     ffffiiiinnnnddddNNNNeeeexxxxtttt(((())))

          static iflFormat* findNext(int& index,
                                     int openDSOifNecessary = TRUE)


          This static class member function is used to step through the
          (static, lazily created) list of supported file formats.

          To start searching initialize the _i_n_d_e_x paramter to zero.  It will
          be automatically updated by each call so that successive calls will
          iterate through all available formats.  If there are no more
          formats, the function returns NULL.

          If _o_p_e_n_D_S_O_i_f_N_e_c_e_s_s_a_r_y is false, then no DSOs will be opened, and
          only formats whose DSOs have already been opened will be returned.

          The following example prints the names of all supported formats:
          (note that iflDatabase can do this too):

              iflFormat* fmt;
              int index = 0;
              while ((fmt = iflFormat::findNext(index)) != NULL)
                  printf("%s\n", fmt->getName());


     ggggeeeettttDDDDeeeeffffaaaauuuullllttttSSSSuuuuffffffffiiiixxxx(((())))

          const char* getDefaultSuffix()


          This member function returns the default filename suffix (the first
          suffix listed in the "suffixes" declaration for a format in the IFL
          format database).  The returned value is a pointer to a static
          string that is valid forever.  Note that the returned value may be
          NULL.



                                                                        PPPPaaaaggggeeee 5555






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



     ggggeeeettttDDDDeeeessssccccrrrriiiippppttttiiiioooonnnn(((())))

          const char* getDescription()


          This member function returns the format description, or NULL if
          there is none.

     ggggeeeettttNNNNaaaammmmeeee(((())))

          const char* getName()


          This member function returns the format name, which is a pointer to
          a static string that is valid forever.

     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddCCCCoooolllloooorrrrMMMMooooddddeeeellll(((())))

          virtual iflColorModel getPreferredColorModel(int nc=0)


          This virtual member function returns the image file format's
          "preferred" value for the color model attribute for an image with _n_c
          channels. If _n_c is zero the most common color model will be
          returned.  The returned value must be one of the supported color
          models, as reported by the ccccoooolllloooorrrrMMMMooooddddeeeellllIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd() method.

     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddCCCCoooommmmpppprrrreeeessssssssiiiioooonnnn(((())))

          virtual iflCompression getPreferredCompression()


          This virtual member function returns the image file format's
          "preferred" value for the compression attribute. The returned value
          must be one of the supported compressions, as reported by the
          ccccoooommmmpppprrrreeeessssssssiiiioooonnnnIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd() method.

     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddOOOOrrrrddddeeeerrrr(((())))

          virtual iflOrder getPreferredOrder()


          This virtual member function returns the image file format's
          "preferred" value for the order attribute. The returned value must
          be one of the supported orders, as reported by the
          oooorrrrddddeeeerrrrIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd() method.

     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddOOOOrrrriiiieeeennnnttttaaaattttiiiioooonnnn(((())))

          virtual iflOrientation getPreferredOrientation()





                                                                        PPPPaaaaggggeeee 6666






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



          This virtual member function returns the image file format's
          "preferred" value for the orientation attribute. The returned value
          must be one of the supported orientations, as reported by the
          oooorrrriiiieeeennnnttttaaaattttiiiioooonnnnIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd() method.

     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddPPPPaaaaggggeeeeSSSSiiiizzzzeeee(((())))

          virtual void getPreferredPageSize(int iWidth, int iHeight,
                                            int iz, int ic, int& pWidth,
                                            int& pHeight, int& pz,
                                            int& pc, iflOrientation orientation)


          This virtual member function returns the image file format's
          "preferred" page size, _p_W_i_d_t_h, _p_H_e_i_g_h_t, _p_z and _p_c, for an image
          whose size is _i_W_i_d_t_h, _i_H_e_i_g_h_t, _i_z and _i_c (which must be a supported
          page size; the caller can check this by calling
          ppppaaaaggggeeeeSSSSiiiizzzzeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd()).

     ggggeeeettttPPPPrrrreeeeffffeeeerrrrrrrreeeeddddTTTTyyyyppppeeee(((())))

          virtual iflDataType getPreferredType()


          This virtual member function returns the image file format's
          "preferred" value for the data type attribute. The returned value
          must be one of the supported data types, as reported by the
          ttttyyyyppppeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd() method.

     hhhhaaaavvvveeeeDDDDSSSSOOOOVVVVeeeerrrrssssiiiioooonnnn(((())))

          int haveDSOVersion(int major, int minor)


          This member function returns TRUE if the DSO loaded is the same of
          newer than the indicated major and minor version numbers.

     hhhhaaaavvvveeeeIIIICCCCCCCC(((())))

          int haveICC()


          This member function returns TRUE if the DSO loaded supports the ICC
          methods: ggggeeeettttIIIICCCCCCCCPPPPrrrrooooffffiiiilllleeee(), ffffrrrreeeeeeeeIIIICCCCCCCCPPPPrrrrooooffffiiiilllleeee() and sssseeeettttIIIICCCCCCCCPPPPrrrrooooffffiiiilllleeee().

     oooorrrrddddeeeerrrrIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int orderIsSupported(iflOrder order)







                                                                        PPPPaaaaggggeeee 7777






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



          This virtual member function tells whether the given dimension order
          is supported by the image file format.

     oooorrrriiiieeeennnnttttaaaattttiiiioooonnnnIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int orientationIsSupported(iflOrientation orientation)


          This virtual member function tells whether the given orientation is
          supported by the image file format.

     ppppaaaaggggeeeeSSSSiiiizzzzeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int pageSizeIsSupported(int iWidth, int iHeight,
                                          int iz, int ic, int pWidth,
                                          int pHeight, int pz,
                                          int pc, iflOrientation orientation)


          This virtual member function tells whether the image file format
          supports the given page size, _p_W_i_d_t_h, _p_H_e_i_g_h_t, _p_z and _p_c, for an
          image whose size is _i_W_i_d_t_h, _i_H_e_i_g_h_t, _i_z and _i_c (which must be a
          supported image size; the caller can check this by calling
          ssssiiiizzzzeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd()).

     ppppaaaaggggiiiinnnnggggIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int pagingIsSupported()


          This virtual member function tells whether the image file format
          supports any page size other than the entire image size.

          This might be useful to a GUI application that allows the user to
          enter a page size; the text entry widget could be disabled if paging
          is not supported.

     rrrraaaannnnddddoooommmmAAAAcccccccceeeessssssssRRRReeeeaaaaddddIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int randomAccessReadIsSupported()


          This virtual member function tells whether the corresponding iflFile
          subclass supports random access reads (as opposed to requiring that
          reads occur sequentially).

          If the subclass does not support random access reads, out-of-order
          calls to ggggeeeettttPPPPaaaaggggeeee() may return
          iflStatusEncode(iflUNSUPPORTEDBYFORMAT) (if the limitation is
          inherent in the file format) or
          iflStatusEncode(iflUNSUPPORTEDBYLIBRARY) (if the limitation is due
          to the implementation of the iflFile subclass).



                                                                        PPPPaaaaggggeeee 8888






iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))      IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll       iiiiffffllllFFFFoooorrrrmmmmaaaatttt((((3333))))



          This function is irrelevant for formats that do not support reading
          or that do not support paging.

     rrrraaaannnnddddoooommmmAAAAcccccccceeeessssssssWWWWrrrriiiitttteeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int randomAccessWriteIsSupported()


          This virtual member function tells whether the corresponding iflFile
          subclass supports random access writes (as opposed to requiring that
          writes occur sequentially).

          If the subclass does not support random access writes, out-of-order
          calls to sssseeeettttPPPPaaaaggggeeee() may return
          iflStatusEncode(iflUNSUPPORTEDBYFORMAT) (if the limitation is
          inherent in the file format) or
          iflStatusEncode(iflUNSUPPORTEDBYLIBRARY) (if the limitation is due
          to the implementation of the iflFile subclass).

          This function is irrelevant for formats that do not support writing
          or that do not support paging.

     ssssiiiizzzzeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int sizeIsSupported(int width, int height, int z,
                                      int c, iflOrientation orientation)


          This virtual member function tells whether the given image size,
          _w_i_d_t_h, _h_e_i_g_h_t, _z and _c, (which the caller must guarantee are all
          positive values) is supported by the image file format.

     ttttyyyyppppeeeeIIIIssssSSSSuuuuppppppppoooorrrrtttteeeedddd(((())))

          virtual int typeIsSupported(iflDataType type)


          This virtual member function tells whether the given data type is
          supported by the image file format.

SSSSEEEEEEEE AAAALLLLSSSSOOOO
     iflFile, iflDatabase


NNNNOOOOTTTTEEEE
     Applications that use iflFormat functionality should check to see whether
     the less-filling iflDatabase satisfies its needs.








                                                                        PPPPaaaaggggeeee 9999